/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import { ApiError } from '../core/ApiError';
import type { ApiRequestOptions } from '../core/ApiRequestOptions';
import type { ApiResult } from '../core/ApiResult';
import { CancelablePromise } from '../core/CancelablePromise';
import type { OnCancel } from '../core/CancelablePromise';
import type { OpenAPIConfig } from '../core/OpenAPI';
class FormData {
	private data = {};
	private files : any = null;
	append(name : string, value : any) {
		if (name == 'files') {
			this.files = value;
		} else {
			this.data[name] = value;
		}
	}
	getFiles() {
		return this.files;
	}

	getData() {
		return this.data;
	}
}




const isDefined = <T>(value : T | null | undefined) : value is Exclude<T, null | undefined> => {
	return value !== undefined && value !== null;
};

const isString = (value : any) : value is string => {
	return typeof value === 'string';
};

const isStringWithValue = (value : any) : value is string => {
	return isString(value) && value !== '';
};

const isBlob = (value : any) : value is Blob => {
	return (
		typeof value === 'object' &&
		typeof value.type === 'string' &&
		typeof value.stream === 'function' &&
		typeof value.arrayBuffer === 'function' &&
		typeof value.constructor === 'function' &&
		typeof value.constructor.name === 'string' &&
		/^(Blob|File)$/.test(value.constructor.name) &&
		/^(Blob|File)$/.test(value[Symbol.toStringTag])
	);
};

const isFormData = (value : any) : value is FormData => {
	return value instanceof FormData;
};

const base64 = (str : string) : string => {
	try {
		return btoa(str);
	} catch (err) {
		// @ts-ignore
		return Buffer.from(str).toString('base64');
	}
};

const getQueryString = (params : Record<string, any>) : string => {
	const qs : string[] = [];

	const append = (key : string, value : any) => {
		qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
	};

	const process = (key : string, value : any) => {
		if (isDefined(value)) {
			if (Array.isArray(value)) {
				value.forEach(v => {
					process(key, v);
				});
			} else if (typeof value === 'object') {
				Object.entries(value).forEach(([k, v]) => {
					process(`${key}[${k}]`, v);
				});
			} else {
				append(key, value);
			}
		}
	};

	Object.entries(params).forEach(([key, value]) => {
		process(key, value);
	});

	if (qs.length > 0) {
		return `?${qs.join('&')}`;
	}

	return '';
};

const getUrl = (config : OpenAPIConfig, options : ApiRequestOptions) : string => {
	const encoder = config.ENCODE_PATH || encodeURI;

	const path = options.url
		.replace('{api-version}', config.VERSION)
		.replace(/{(.*?)}/g, (substring : string, group : string) => {
			if (options.path?.hasOwnProperty(group)) {
				return encoder(String(options.path[group]));
			}
			return substring;
		});

	const url = `${config.BASE}${path}`;
	if (options.query) {
		return `${url}${getQueryString(options.query)}`;
	}
	return url;
};

const getFormData = (options : ApiRequestOptions) : FormData | undefined => {
	if (options.formData) {
		const formData = new FormData();

		const process = (key : string, value : any) => {
			if (isString(value) || isBlob(value)) {
				formData.append(key, value);
			} else {
				formData.append(key, JSON.stringify(value));
			}
		};

		Object.entries(options.formData)
			.filter(([_, value]) => isDefined(value))
			.forEach(([key, value]) => {
				if (Array.isArray(value)) {
					value.forEach(v => process(key, v));
				} else {
					process(key, value);
				}
			});

		return formData;
	}
	return undefined;
};

type Resolver<T> = (options : ApiRequestOptions) => Promise<T>;

const resolve = async <T>(options : ApiRequestOptions, resolver ?: T | Resolver<T>) : Promise<T | undefined> => {
	if (typeof resolver === 'function') {
		return (resolver as Resolver<T>)(options);
	}
	return resolver;
};

const getHeaders = async (config : OpenAPIConfig, options : ApiRequestOptions) : Promise<any> => {
	const token = await resolve(options, config.TOKEN);
	const username = await resolve(options, config.USERNAME);
	const password = await resolve(options, config.PASSWORD);
	const additionalHeaders = await resolve(options, config.HEADERS);

	const headers = Object.entries({
		Accept: 'application/json',
		...additionalHeaders,
		...options.headers,
	})
		.filter(([_, value]) => isDefined(value))
		.reduce((headers, [key, value]) => ({
			...headers,
			[key]: String(value),
		}), {} as Record<string, string>);

	if (isStringWithValue(token)) {
		headers['Authorization'] = `Bearer ${token}`;
	}

	if (isStringWithValue(username) && isStringWithValue(password)) {
		const credentials = base64(`${username}:${password}`);
		headers['Authorization'] = `Basic ${credentials}`;
	}

	if (options.body) {
		if (options.mediaType) {
			headers['Content-Type'] = options.mediaType;
		} else if (isBlob(options.body)) {
			headers['Content-Type'] = options.body.type || 'application/octet-stream';
		} else if (isString(options.body)) {
			headers['Content-Type'] = 'text/plain';
		} else if (!isFormData(options.body)) {
			headers['Content-Type'] = 'application/json';
		}
	}
	headers['Authorization'] = uni.getStorageSync("access-token");
	headers["X-Authorization"] = uni.getStorageSync("x-access-token");
	return headers;
};

const getRequestBody = (options : ApiRequestOptions) : any => {
	if (options.body) {
		if (options.mediaType?.includes('/json')) {
			return JSON.stringify(options.body)
		} else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
			return options.body;
		} else {
			return JSON.stringify(options.body);
		}
	}
	return undefined;
};

export const sendRequest = async (
	config : OpenAPIConfig,
	options : ApiRequestOptions,
	url : string,
	body : any,
	formData : FormData | undefined,
	headers : any,
	onCancel : OnCancel
) : Promise<Response> => {

	const request : RequestInit = {
		headers,
		body: body ?? formData,
		method: options.method,
	};
	if (config.WITH_CREDENTIALS) {
		request.credentials = config.CREDENTIALS;
	}
	if (formData) {
		if (formData.getFiles()) {
			return new Promise((_resolve : any, _reject) => {
				let task = uni.uploadFile({
					url,
					filePath: formData.getFiles(),
					name: 'files',
					formData: formData.getData(),
					header: request.headers,
					success: _resolve,
					fail: _reject
				});
				onCancel(() => task.abort());
			});
		} else {
			headers['content-type'] = 'application/x-www-form-urlencoded';
			return new Promise((_resolve : any, _reject) => {
				let task = uni.request({
					url,
					data: formData.getData(),
					header: request.headers,
					method: request.method?.toUpperCase() as any,
					success: _resolve,
					fail: _reject
				});
				onCancel(() => task.abort());
			});
		}
	} else {
		return new Promise((_resolve : any, _reject) => {
			let task = uni.request({
				url: url,
				data: request.body,
				header: request.headers,
				method: request.method?.toUpperCase() as any,
				success: _resolve,
				fail: _reject
			});
			onCancel(() => task.abort());
		});
	}

};

const getResponseHeader = (response : any, responseHeader ?: string) : string | undefined => {
	if (responseHeader) {
		const content = (response.headers || response.header)[responseHeader];
		if (isString(content)) {
			return content;
		}
	}
	var accessToken = (response.headers || response.header)["access-token"];
	var xAccessToken = (response.headers || response.header)["x-access-token"];
	// 处理无效 `token` 问题
	if (accessToken === "invalid_token") {
		uni.removeStorageSync("access-token");
		uni.removeStorageSync("x-access-token");
	}
	// 处理自动刷新
	else if (xAccessToken && accessToken && accessToken !== "invalid_token") {
		uni.setStorageSync("access-token", `Bearer ${accessToken}`);
		uni.setStorageSync("x-access-token", `Bearer ${xAccessToken}`);
	}
	return response;
};

const getResponseBody = async (response : any) : Promise<any> => {
	if (response.status !== 204) {
		try {
			const contentType = response.header['Content-Type'];
			if (contentType) {
				const isJSON = contentType.toLowerCase().startsWith('application/json');
				if (isJSON) {
					return response.data;
				} else {
					return response.data;
				}
			}
		} catch (error) {
			console.error(error);
		}
	}
	return response;
};

const catchErrorCodes = (options : ApiRequestOptions, result : ApiResult) : void => {
	const errors : Record<number, string> = {
		400: 'Bad Request',
		401: 'Unauthorized',
		403: 'Forbidden',
		404: 'Not Found',
		500: 'Internal Server Error',
		502: 'Bad Gateway',
		503: 'Service Unavailable',
		...options.errors,
	}

	const error = errors[result.status];
	if (error) {
		throw new ApiError(options, result, error);
	}

	if (!result.ok) {
		throw new ApiError(options, result, 'Generic Error');
	}
};

/**
 * Request method
 * @param config The OpenAPI configuration object
 * @param options The request options from the service
 * @returns CancelablePromise<T>
 * @throws ApiError
 */
export const request = <T>(config : OpenAPIConfig, options : ApiRequestOptions) : CancelablePromise<T> => {
	return new CancelablePromise(async (resolve, reject, onCancel) => {
		try {
			const url = getUrl(config, options);
			const formData = getFormData(options);
			const body = getRequestBody(options);
			const headers = await getHeaders(config, options);
			if (!onCancel.isCancelled) {
				const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
				const responseBody = await getResponseBody(response);
				const responseHeader = getResponseHeader(response, options.responseHeader);

				const result : ApiResult = {
					url,
					ok: response.ok,
					status: response.status,
					statusText: response.statusText,
					body: responseHeader?.data ?? responseBody.data,
				};

				// catchErrorCodes(options, result);

				resolve(result.body);
			}
		} catch (error) {
			reject(error);
		}
	});
};